/**
 * 图片处理控制器
 * @module controllers/image
 */

const imageService = require('../services/image.service');
const fs = require('fs');
const path = require('path');
// 临时注释掉 archiver，因为安装失败
// const archiver = require('archiver');
const config = require('../config/config');

/**
 * 处理图片压缩请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.compressImage = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.file) {
      return res.status(400).json({
        code: 400,
        message: '请上传图片文件',
        errors: [{
          field: 'file',
          message: '请上传图片文件'
        }]
      });
    }
    
    // 从请求体中获取压缩选项
    const options = {
      quality: parseInt(req.body.quality, 10) || 75,
      resize: req.body.resize === 'true',
      maxWidth: parseInt(req.body.maxWidth, 10) || 1920,
      maxHeight: parseInt(req.body.maxHeight, 10) || 1080,
      format: req.body.format || 'original'
    };
    
    // 压缩图片
    const result = await imageService.compressImage(req.file, options);
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回压缩结果
    res.status(200).json({
      code: 200,
      message: '压缩成功',
      data: result
    });
  } catch (error) {
    // 清理上传的临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    next(error);
  }
};

/**
 * 处理批量图片压缩请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.compressBatch = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.files || req.files.length === 0) {
      return res.status(400).json({
        code: 400,
        message: '请上传至少一个图片文件',
        errors: [{
          field: 'files',
          message: '请上传至少一个图片文件'
        }]
      });
    }
    
    // 从请求体中获取压缩选项
    const options = {
      quality: parseInt(req.body.quality, 10) || 75,
      resize: req.body.resize === 'true',
      maxWidth: parseInt(req.body.maxWidth, 10) || 1920,
      maxHeight: parseInt(req.body.maxHeight, 10) || 1080,
      format: req.body.format || 'original'
    };
    
    // 批量压缩图片
    const results = [];
    let totalOriginalSize = 0;
    let totalCompressedSize = 0;
    
    for (const file of req.files) {
      const result = await imageService.compressImage(file, options);
      results.push({
        filename: file.originalname,
        originalSize: result.originalSize,
        compressedSize: result.compressedSize,
        compressionRatio: result.compressionRatio,
        downloadUrl: result.downloadUrl
      });
      
      totalOriginalSize += result.originalSize;
      totalCompressedSize += result.compressedSize;
    }
    
    // 由于无法安装 archiver，使用临时替代方案 - 不创建 ZIP 文件，直接返回单独的文件
    // 设置过期时间（7天后）
    const now = new Date();
    const expiryTime = new Date(now.setDate(now.getDate() + 7)).toISOString();
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回单独的文件结果，不生成 ZIP
    const compressionRatio = Math.round((1 - totalCompressedSize / totalOriginalSize) * 100);
    
    res.status(200).json({
      code: 200,
      message: '批量压缩成功',
      data: {
        totalOriginalSize,
        totalCompressedSize,
        compressionRatio,
        fileCount: req.files.length,
        files: results,
        // 不提供 batchDownloadUrl，因为没有创建 ZIP 文件
        note: "由于技术限制，暂时无法提供批量下载，请分别下载每个文件",
        expiryTime
      }
    });
    
    /* 原始 ZIP 创建代码，需要 archiver 模块
    // 创建ZIP文件
    const timestamp = Date.now();
    const zipFilename = `batch_${timestamp}.zip`;
    const zipPath = path.join(config.uploadDir, zipFilename);
    
    const output = fs.createWriteStream(zipPath);
    const archive = archiver('zip', {
      zlib: { level: 9 } // 最高压缩级别
    });
    
    // 监听管道关闭
    output.on('close', () => {
      // ZIP文件创建完成，返回响应
      const zipSize = fs.statSync(zipPath).size;
      const compressionRatio = Math.round((1 - totalCompressedSize / totalOriginalSize) * 100);
      
      // 设置过期时间（7天后）
      const now = new Date();
      const expiryTime = new Date(now.setDate(now.getDate() + 7)).toISOString();
      
      // TODO: 在实现使用统计功能后，记录使用情况
      
      res.status(200).json({
        code: 200,
        message: '批量压缩成功',
        data: {
          totalOriginalSize,
          totalCompressedSize,
          compressionRatio,
          fileCount: req.files.length,
          files: results,
          batchDownloadUrl: `/uploads/${zipFilename}`,
          expiryTime
        }
      });
    });
    
    // 错误处理
    archive.on('error', (err) => {
      throw err;
    });
    
    // 管道连接
    archive.pipe(output);
    
    // 添加压缩后的文件到ZIP
    for (const result of results) {
      const filePath = path.join(process.cwd(), result.downloadUrl);
      const filename = path.basename(result.downloadUrl);
      archive.file(filePath, { name: filename });
    }
    
    // 完成打包
    await archive.finalize();
    */
    
  } catch (error) {
    // 清理上传的临时文件
    if (req.files) {
      for (const file of req.files) {
        if (file.path && fs.existsSync(file.path)) {
          fs.unlinkSync(file.path);
        }
      }
    }
    
    next(error);
  }
};

/**
 * 处理图片格式转换请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.convertImage = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.file) {
      return res.status(400).json({
        code: 400,
        message: '请上传图片文件',
        errors: [{
          field: 'file',
          message: '请上传图片文件'
        }]
      });
    }
    
    // 从请求体中获取转换选项
    const options = {
      format: req.body.format || 'webp',
      quality: parseInt(req.body.quality, 10) || 90
    };
    
    // 检查格式是否有效
    const validFormats = ['jpg', 'jpeg', 'png', 'webp', 'gif'];
    if (!validFormats.includes(options.format)) {
      return res.status(400).json({
        code: 400,
        message: '不支持的格式',
        errors: [{
          field: 'format',
          message: `格式必须是以下之一: ${validFormats.join(', ')}`
        }]
      });
    }
    
    // 转换图片
    const result = await imageService.convertImage(req.file, options);
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回转换结果
    res.status(200).json({
      code: 200,
      message: '转换成功',
      data: result
    });
  } catch (error) {
    // 清理上传的临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    next(error);
  }
};

/**
 * 处理图片裁剪请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.cropImage = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.file) {
      return res.status(400).json({
        code: 400,
        message: '请上传图片文件',
        errors: [{
          field: 'file',
          message: '请上传图片文件'
        }]
      });
    }
    
    // 从请求体中获取裁剪选项
    const options = {
      x: parseInt(req.body.x, 10) || 0,
      y: parseInt(req.body.y, 10) || 0,
      width: parseInt(req.body.width, 10) || 100,
      height: parseInt(req.body.height, 10) || 100,
      format: req.body.format || 'original'
    };
    
    // 裁剪图片
    const result = await imageService.cropImage(req.file, options);
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回裁剪结果
    res.status(200).json({
      code: 200,
      message: '裁剪成功',
      data: result
    });
  } catch (error) {
    // 清理上传的临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    next(error);
  }
};

/**
 * 处理图片旋转请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.rotateImage = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.file) {
      return res.status(400).json({
        code: 400,
        message: '请上传图片文件',
        errors: [{
          field: 'file',
          message: '请上传图片文件'
        }]
      });
    }
    
    // 从请求体中获取旋转选项
    const options = {
      rotation: parseInt(req.body.rotation, 10) || 0,
      flipHorizontal: req.body.flipHorizontal === 'true',
      flipVertical: req.body.flipVertical === 'true',
      format: req.body.format || 'original'
    };
    
    // 验证旋转角度
    const validRotations = [0, 90, 180, 270];
    if (!validRotations.includes(options.rotation)) {
      return res.status(400).json({
        code: 400,
        message: '无效的旋转角度',
        errors: [{
          field: 'rotation',
          message: `旋转角度必须是以下之一: ${validRotations.join(', ')}`
        }]
      });
    }
    
    // 旋转图片
    const result = await imageService.rotateImage(req.file, options);
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回旋转结果
    res.status(200).json({
      code: 200,
      message: '旋转成功',
      data: result
    });
  } catch (error) {
    // 清理上传的临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    next(error);
  }
};

/**
 * 处理添加水印请求
 * @param {Object} req - Express请求对象
 * @param {Object} res - Express响应对象
 * @param {Function} next - Express下一个中间件函数
 */
exports.addWatermark = async (req, res, next) => {
  try {
    // 检查是否有文件上传
    if (!req.file) {
      return res.status(400).json({
        code: 400,
        message: '请上传图片文件',
        errors: [{
          field: 'file',
          message: '请上传图片文件'
        }]
      });
    }
    
    // 从请求体中获取水印选项
    const options = {
      watermarkType: req.body.watermarkType || 'text',
      position: req.body.position || 'bottomRight',
      opacity: parseFloat(req.body.opacity) || 0.5,
      size: parseFloat(req.body.size) || 0.2,
      format: req.body.format || 'original'
    };
    
    // 根据水印类型设置额外参数
    if (options.watermarkType === 'text') {
      options.watermarkText = req.body.watermarkText || '柯基工具箱';
      
      if (!options.watermarkText) {
        return res.status(400).json({
          code: 400,
          message: '水印文本不能为空',
          errors: [{
            field: 'watermarkText',
            message: '水印文本不能为空'
          }]
        });
      }
    } else if (options.watermarkType === 'image') {
      if (!req.files || !req.files.watermarkImage) {
        return res.status(400).json({
          code: 400,
          message: '请上传水印图片',
          errors: [{
            field: 'watermarkImage',
            message: '请上传水印图片'
          }]
        });
      }
      
      options.watermarkImage = req.files.watermarkImage[0];
    } else {
      return res.status(400).json({
        code: 400,
        message: '无效的水印类型',
        errors: [{
          field: 'watermarkType',
          message: '水印类型必须是 text 或 image'
        }]
      });
    }
    
    // 验证位置参数
    const validPositions = ['center', 'topLeft', 'topRight', 'bottomLeft', 'bottomRight'];
    if (!validPositions.includes(options.position)) {
      return res.status(400).json({
        code: 400,
        message: '无效的水印位置',
        errors: [{
          field: 'position',
          message: `水印位置必须是以下之一: ${validPositions.join(', ')}`
        }]
      });
    }
    
    // 添加水印
    const result = await imageService.addWatermark(req.file, options);
    
    // TODO: 在实现使用统计功能后，记录使用情况
    
    // 返回结果
    res.status(200).json({
      code: 200,
      message: '添加水印成功',
      data: result
    });
  } catch (error) {
    // 清理上传的临时文件
    if (req.file && req.file.path && fs.existsSync(req.file.path)) {
      fs.unlinkSync(req.file.path);
    }
    
    if (req.files && req.files.watermarkImage) {
      const watermarkFile = req.files.watermarkImage[0];
      if (watermarkFile && watermarkFile.path && fs.existsSync(watermarkFile.path)) {
        fs.unlinkSync(watermarkFile.path);
      }
    }
    
    next(error);
  }
}; 